mode 0.0.5 → 0.0.7

data/spec/commands/login_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe Mode::Commands::Login do
+  let(:tmpdir) { Dir.mktmpdir }
+  let(:username) { 'besquared' }
+  let(:password) { 'password' }
+
+  let(:personal_repr) {
+    {
+      'name' => 'personal',
+      'token' => 'token123',
+      'account_name' => 'besquared'
+    }
+  }
+
+  let(:secondary_repr) {
+    {
+      'name' => 'secondary',
+      'token' => 'token567',
+      'account_name' => 'besquared'
+    }
+  }
+
+  let(:tokens_resource) {
+    Mode::API::Resource.new({
+      '_embedded' => {
+        'access_tokens' => [
+          personal_repr,
+          secondary_repr
+        ]
+      }
+    })
+  }
+
+  let(:single_tokens_resource) {
+    Mode::API::Resource.new({
+      '_embedded' => {
+        'access_tokens' => [
+          personal_repr
+        ]
+      }
+    })
+  }
+
+  let(:personal_token) {
+    Mode::Auth::AccessToken.new(
+      Mode::API::Resource.new(personal_repr)
+    )
+  }
+
+  let(:secondary_token) {
+    Mode::Auth::AccessToken.new(
+      Mode::API::Resource.new(secondary_repr)
+    )
+  }
+
+  before do
+    initialize_logger
+  end
+
+  it "initializes with each environment" do
+    [:test, :staging, :development, :production].each do |env|
+      Mode::Commands::Login.new(env => true)
+    end
+  end
+
+  it "executes a login process with a new config" do
+    command = Mode::Commands::Login.new
+
+    command.stub(:say)
+    command.stub(:config_dir).and_return(tmpdir)
+    
+    command.should_receive(:configure_credentials).and_return([username, password])
+    command.should_receive(:choose_access_token).and_return(personal_token)
+
+    command.execute
+
+    config = Mode::Config.new(tmpdir)
+
+    config.username.should == 'besquared'
+    config.access_token.should == 'token123'
+  end
+
+  it "executes a login process with an existing config" do
+    command = Mode::Commands::Login.new
+
+    command.stub(:say)
+    command.stub(:config_dir).and_return(tmpdir)
+
+    Mode::Config.init(tmpdir)
+
+    command.should_receive(:configure_credentials).and_return([username, password])
+    command.should_receive(:choose_access_token).and_return(personal_token)
+
+    command.execute
+
+    config = Mode::Config.new(tmpdir)
+
+    config.username.should == 'besquared'
+    config.access_token.should == 'token123'
+  end
+
+  it "rescues and displays errors during the login process" do
+    command = Mode::Commands::Login.new
+
+    command.stub(:config_dir).and_return(tmpdir)
+
+    error = StandardError.new("Expected Break")
+    command.should_receive(:configure_credentials).and_raise(error)
+    
+    command.should_receive(:say).with("Expected Break")
+
+    command.execute
+  end
+
+  it "configures API with credentials" do
+    command = Mode::Commands::Login.new(:test => true)
+
+    command.send(:configure_api, 'besquared', 'password')
+
+    Mode::API::Request.environment.should == :test
+  end
+
+  it "requests credentials and configures API" do
+    command = Mode::Commands::Login.new(:test => true)
+
+    command.should_receive(:configure_api)
+    command.should_receive(:ask).and_return('besquared', 'password')
+
+    username, password = command.send(:configure_credentials)
+
+    username.should == 'besquared'
+    password.should == 'password'
+  end
+
+  it "raises when credentials are invalid" do
+    command = Mode::Commands::Login.new(:test => true)
+
+    response = double(:response, :status => 401)
+    Mode::API::Request.should_receive(:get).with(:access_tokens).and_return(response)
+    expect { command.send(:fetch_access_tokens) }.to raise_error
+  end
+
+  it "fetches access tokens from the API" do
+    command = Mode::Commands::Login.new(:test => true)
+    Mode::API::Request.should_receive(:get).with(:access_tokens).and_return(tokens_resource)
+
+    tokens = command.send(:fetch_access_tokens)
+
+    tokens.length.should == 2
+    tokens.first.token.should == 'token123'
+    tokens.last.token.should == 'token567'
+  end
+
+  it "chooses the first token if there is only one" do
+    command = Mode::Commands::Login.new(:test => true)
+    Mode::API::Request.should_receive(:get).with(:access_tokens).and_return(single_tokens_resource)
+
+    command.should_not_receive(:ask)
+
+    chosen_token = command.send(:choose_access_token)
+
+    chosen_token.should_not == nil
+    chosen_token.token.should == 'token123'
+  end
+
+  it "prompts the user to choose a token" do
+    command = Mode::Commands::Login.new(:test => true)
+    Mode::API::Request.should_receive(:get).with(:access_tokens).and_return(tokens_resource)
+
+    command.should_receive(:ask).and_return("2")
+
+    chosen_token = command.send(:choose_access_token)
+
+    chosen_token.should_not == nil
+    chosen_token.token.should == 'token567'
+  end
+end

data/spec/config_spec.rb

@@ -1,12 +1,14 @@
 require 'spec_helper'
 
 describe Mode::Config do
-  before(:each) do
-    @tmpdir = Dir.mktmpdir
-  end
+  let(:tmpdir) { Dir.mktmpdir }
 
   it "should initialize" do
-    config = Mode::Config.init(@tmpdir)
+    Mode::Config.exists?(tmpdir).should == false
+
+    config = Mode::Config.init(tmpdir)
+    Mode::Config.exists?(tmpdir).should == true
+    
     config.username.should == nil
     config.access_token.should == nil
   end
@@ -16,7 +18,7 @@ describe Mode::Config do
   end
 
   it "should save" do
-    config = Mode::Config.init(@tmpdir)
+    config = Mode::Config.init(tmpdir)
     config.username = 'besquared'
     config.access_token = 'token'
     config.save
@@ -25,10 +27,10 @@ describe Mode::Config do
   end
 
   it "should have FILENAME" do
-    Mode::Config::FILENAME.should == '.mode.yml'
+    Mode::Config::default_filename.should == 'config.yml'
   end
 
   it "should generate full path" do
-    Mode::Config.full_path(@tmpdir).should == File.join(@tmpdir, '.mode.yml')
+    Mode::Config.full_path(tmpdir).should == File.join(tmpdir, 'config.yml')
   end
 end

data/spec/connector/config_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Mode::Connector::Config do
+  let(:tmpdir) { Dir.mktmpdir }
+  
+  before do
+    initialize_logger
+  end
+
+  it "should initialize" do
+    Mode::Connector::Config.exists?(tmpdir).should == false
+    config = Mode::Connector::Config.init(tmpdir)
+    Mode::Connector::Config.exists?(tmpdir).should == true
+    
+    config.data_sources.should == []
+  end
+
+  it "should initialize with data sources" do
+    config = Mode::Connector::Config.init(tmpdir)
+    config.data_sources << Mode::Connector::DataSource.new('test', {})
+    config.save
+
+    config = Mode::Connector::Config.new(tmpdir)
+    config.data_sources.length.should == 1
+  end
+  
+  it "should raise if config file doesn't exist" do
+    expect { config = Mode::Connector::Config.new('fake.yml') }.to raise_error
+  end
+
+  it "should save" do
+    config = Mode::Connector::Config.init(tmpdir)
+    config.data_sources << Mode::Connector::DataSource.new('test', {})
+    config.save
+
+    File.read(config.path).should == config.send(:to_yaml)
+  end
+
+  it "should have FILENAME" do
+    Mode::Connector::Config::default_filename.should == 'connect.yml'
+  end
+
+  it "should generate full path" do
+    Mode::Connector::Config.full_path(tmpdir).should == File.join(tmpdir, 'connect.yml')
+  end
+end

data/spec/connector/daemon_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Mode::Connector::Daemon do
+  let(:working_dir) { Dir.mktmpdir }
+  let(:scheduler) { double(:scheduler, :start! => true, :stop! => true) }
+
+  before do
+    initialize_logger
+  end
+
+  it "starts a daemon" do
+    daemon = Mode::Connector::Daemon.new(:working_dir => working_dir)
+    Mode::Connector::Scheduler.should_receive(:new).and_return(scheduler)
+
+    begin
+      daemon.start([5, []])
+    ensure
+      daemon.stop
+    end
+  end
+
+  it "logs errors on failure" do
+    daemon = Mode::Connector::Daemon.new(:working_dir => working_dir)
+    Mode::Connector::Scheduler.should_receive(:new).and_raise(StandardError.new("BREAK"))
+
+    Mode::Logger.instance.should_receive(:error)
+
+    daemon.start([5, []])
+  end
+end

data/spec/connector/data_source_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Mode::Connector::DataSource do
+  let(:props) {
+    {
+      'adapter' => 'postgres',
+      'host' => 'localhost',
+      'username' => 'postgres',
+      'database' => 'warehouse',
+      'password' => nil
+    }
+  }
+
+  let(:redprops) {
+    {
+      'adapter' => 'redshift',
+      'host' => 'localhost',
+      'username' => 'postgres',
+      'database' => 'warehouse',
+      'password' => nil
+    }
+  }
+
+  it "initializes with props" do
+    source = Mode::Connector::DataSource.new('dev', props)
+    source.adapter.should == 'postgres'
+    source.host.should == 'localhost'
+    source.username.should == 'postgres'
+    source.database.should == 'warehouse'
+    source.password.should == nil
+  end
+  
+  before do
+    initialize_logger
+  end
+
+  it "has a connection url" do
+    source = Mode::Connector::DataSource.new('dev', props)
+    source.send(:connection_url).should == "postgres://postgres@localhost/warehouse"
+  end
+
+  it "has a connection" do
+    source = Mode::Connector::DataSource.new('dev', props)
+    Sequel.should_receive(:connect).and_return(:connect)
+    source.connection.should == :connect
+  end
+
+  it 'has a connection for redshift' do
+    source = Mode::Connector::DataSource.new('dev', redprops)
+    Sequel.should_receive(:connect).and_return(:connect)
+    source.connection.should == :connect
+  end
+
+  it 'has a connection dataset' do
+    source = Mode::Connector::DataSource.new('dev', props)
+
+    dataset = source.send(:connection_dataset, "SELECT * FROM fake")
+
+    dataset.should_not == nil
+  end
+
+  it "fetches results from dataset" do
+    source = Mode::Connector::DataSource.new('dev', props)
+
+    dataset = double(:dataset)
+    dataset.should_receive(:each).and_yield({'cnt' => 5})
+    source.should_receive(:connection_dataset).with("SELECT 1").and_return(dataset)
+
+    source.select("SELECT 1") do |row|
+      row['cnt'].should == 5
+    end
+  end
+end

data/spec/connector/message_spec.rb

@@ -0,0 +1,22 @@
+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/poller_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Mode::Connector::Poller do
+  let(:path) {
+    Mode::API::Request.data_source_connection_messages_path
+  }
+  
+  before do
+    initialize_logger
+  end
+
+  it "initializes and performs poll" do
+    poller = Mode::Connector::Poller.new
+
+    resource = Mode::API::Resource.new({
+      '_embedded' => {
+        'messages' => [{}, {}]
+      }
+    })
+    Mode::API::Request.should_receive(:get).with(path).and_return(resource)
+    
+    poller.perform! do |message|
+      message.should be_instance_of(Mode::Connector::Message)
+    end
+  end
+end

data/spec/connector/processor_spec.rb

@@ -0,0 +1,93 @@
+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