mode 0.0.10 → 0.0.11

data/lib/mode/connector/scheduler.rb

@@ -10,14 +10,12 @@ module Mode
       def initialize(data_sources, options = {})
         @data_sources = data_sources
         @scheduler    = Rufus::Scheduler.new
-        @max_jobs     = options[:max_jobs] || 4
+        @max_jobs     = (options[:max_jobs] || 4).to_i
       end
 
       def start!
-        data_sources.each(&:connection)
-        # Make sure this stays outside the scheduler
-        
-        scheduler.every('5s') { tick }
+        data_sources.each(&:connection) # Keep outside the scheduler loop
+        scheduler.interval('5s') { tick }
         scheduler.join
       end
 
@@ -39,6 +37,9 @@ module Mode
         if processors.length < max_jobs
           scheduler.in(0, :tag => 'processor') { tock }
         end
+      rescue => err
+        Mode::Logger.instance.error(
+          "Connector::Scheduler", err.message, err.backtrace)
       end
 
       def tock

data/lib/mode/connector/uploader.rb

@@ -10,9 +10,8 @@ module Mode
       end
 
       def perform!
-        Mode::API::Request.put(
-          path,
-          :execution => {
+        Mode::API::Request.put(path,
+          :report_run => {
             :dataset => {
               :count   => count,
               :content => content,
@@ -25,7 +24,7 @@ module Mode
       class << self
         def error!(path, message, detail = nil)
           Mode::API::Request.put(path,
-            :execution => {
+            :report_run => {
               :error => {
                 :detail => detail,
                 :message => message

data/lib/mode/version.rb

@@ -1,3 +1,3 @@
 module Mode
-  VERSION = "0.0.10"
+  VERSION = "0.0.11"
 end

data/mode.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "thor"
   spec.add_runtime_dependency "terminal-table"
 
-  # Data Packaging
+  # Data Packaging (In Development)
   spec.add_runtime_dependency "data_kit"
   spec.add_runtime_dependency "data_package"
 
@@ -34,14 +34,17 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "sequel"
 
   # Concurrency & Processes
-  spec.add_runtime_dependency "daemon-spawn"
+  spec.add_runtime_dependency "spoon"
   spec.add_runtime_dependency "rufus-scheduler"
-  
+    
+  # Web Management
+  # spec.add_runtime_dependency "launchy"
+
   # Development Dependencies
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "profile"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "ruby-prof"
   spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "warbler"
 end

data/spec/api/request_spec.rb

@@ -2,13 +2,16 @@ require 'spec_helper'
 
 describe Mode::API::Request do
   let(:username) { 'besquared' }
-  let(:access_token) { 'access_token '}
+  let(:password) { 'token_password '}
 
   before do
     Mode::API::Request.configure(:test, {
-      :credentials => {
-        :username => username,
-        :access_token => access_token
+      'credentials' => {
+        'username' => username,
+        'password' => password
+      }, 'access_token' => {
+        'token' => 'token123',
+        'password' => 'password123'
       }
     })
   end
@@ -63,10 +66,10 @@ describe Mode::API::Request do
       '/api/besquared/data_source_connections'
 
     Mode::API::Request.data_source_connection_path.should == \
-      '/api/besquared/data_source_connections/access_token'
+      '/api/besquared/data_source_connections/token123'
 
     Mode::API::Request.data_source_connection_messages_path.should == \
-      '/api/besquared/data_source_connections/access_token/messages'
+      '/api/besquared/data_source_connections/token123/messages'
   end
 
   it 'has http object' do

data/spec/commands/connect_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Mode::Commands::Connect do
   let(:tmpdir) { Dir.mktmpdir }
   let(:config) { Mode::Config.init(tmpdir) }
-  let(:connect_config) { Mode::Connector::Config.init(tmpdir) }
+  let(:daemon) { double(:daemon) }
 
   let(:data_source) {
     Mode::Connector::DataSource.new('testdb', {
@@ -19,75 +19,61 @@ describe Mode::Commands::Connect do
     initialize_logger
   end
 
-  it "initializes with command and connect config" do
-    connect = Mode::Commands::Connect.new('start')
-
-    connect.command.should == 'start'
-    connect.concurrency.should == 4
-  end
-
-  it "registers connector" do
-    connect = Mode::Commands::Connect.new('start')
-    
-    registrar = double(:registrar, :perform! => true)
-    Mode::Connector::Registrar.should_receive(:new).and_return(registrar)
-
-    connect.send(:register!)
-  end
-
-  it "starts the daemon" do
-    connect = Mode::Commands::Connect.new('start')
-
-    Mode::Connector::Daemon.should_receive(:spawn!).and_return(true)
-
-    connect.send(:spawn_command!, 'start')
-  end
-
-  it 'restarts the daemon' do
-    connect = Mode::Commands::Connect.new('start')
+  describe "starting" do
+    let(:connect) { Mode::Commands::Connect.new('start') }
 
-    Mode::Connector::Daemon.should_receive(:spawn!).twice.and_return(true)
+    it "initializes with command and connect config" do
+      connect.command.should == 'start'
+      connect.concurrency.should == 4
+    end
 
-    connect.send(:spawn_restart!)
-  end
-
-  it 'spawns with the start command' do
-    connect = Mode::Commands::Connect.new('start')
-
-    Mode::Connector::Daemon.should_receive(:spawn!).and_return(true)
-
-    connect.send(:spawn!)
-  end
-
-  it 'spawns with the restart command' do
-    connect = Mode::Commands::Connect.new('restart')
-
-    Mode::Connector::Daemon.should_receive(:spawn!).twice.and_return(true)
+    it "registers connector" do
+      connect.should_receive(:configuration).and_return(config)
 
-    connect.send(:spawn!)
+      registrar = double(:registrar, :perform! => true)
+      Mode::Connector::Registrar.should_receive(:new).and_return(registrar)
+      connect.send(:register!)
+    end
   end
 
-  it 'spawns with the stop command' do
-    connect = Mode::Commands::Connect.new('stop')
-
-    Mode::Connector::Daemon.should_receive(:spawn!).and_return(true)
-
-    connect.send(:spawn!)
-  end
-
-  it 'raises on spawn if the command is unrecognized' do
-    connect = Mode::Commands::Connect.new('fake')
-
-    Mode::Connector::Daemon.should_not_receive(:spawn!)
-
-    expect { connect.send(:spawn!) }.to raise_error
+  describe "controlling the daemon" do
+    it "starts" do
+      connect = Mode::Commands::Connect.new('start')
+      connect.should_receive(:daemon).and_return(daemon)
+
+      daemon.should_receive(:start).and_return(true)
+      connect.send(:run_command!)
+    end
+
+    it 'stops' do
+      connect = Mode::Commands::Connect.new('stop')
+      connect.should_receive(:daemon).and_return(daemon)
+
+      daemon.should_receive(:stop).and_return(true)
+      connect.send(:run_command!)
+    end
+
+    it 'restarts' do
+      connect = Mode::Commands::Connect.new('restart')
+      connect.should_receive(:daemon).and_return(daemon)
+      
+      daemon.should_receive(:restart).and_return(true)
+      connect.send(:run_command!)
+    end
+    
+    it 'raises on if the command is unrecognized' do
+      connect = Mode::Commands::Connect.new('fake')
+      daemon.should_not_receive(:start)
+      expect { connect.send(:run_command!) }.to raise_error
+    end
   end
 
   it 'executes the connector' do
     connect = Mode::Commands::Connect.new('start')
 
     connect.should_receive(:register!)
-    connect.should_receive(:spawn!)
+    connect.should_receive(:run_command!)
+    connect.should_receive(:validate_config!)
 
     connect.execute
   end

data/spec/commands/helpers_spec.rb

@@ -7,6 +7,7 @@ end
 describe Mode::Commands::Helpers do
   let(:tmpdir) { Dir.mktmpdir }
   let(:command) { CommandClass.new }
+  let(:config) { Mode::Config.init(tmpdir) }
 
   before do
     initialize_logger
@@ -16,18 +17,10 @@ describe Mode::Commands::Helpers do
     command.config_dir.should == File.expand_path("~/.mode/")
   end
 
-  it "provides a config path" do
-    command.config_path.should == Mode::Config.full_path("~/.mode/")
-  end
-
   it "provides config validation" do
-    command.stub(:config_dir).and_return(tmpdir)
+    command.stub(:config_exists).and_return(false)
 
     expect { command.require_config! }.to raise_error
-
-    config = Mode::Config.init(tmpdir)
-
-    command.require_config!
   end
 
   it "provides credential validation" do
@@ -36,8 +29,6 @@ describe Mode::Commands::Helpers do
     # raise for no config
     expect { command.require_credentials! }.to raise_error
 
-    config = Mode::Config.init(tmpdir)
-
     # raise for credentials not found
     expect { command.require_credentials! }.to raise_error
 
@@ -49,21 +40,17 @@ describe Mode::Commands::Helpers do
   end
 
   it "provides api request configuration" do
+    command.stub(:config).and_return(config)
+
     command.configure_api_requests!
     Mode::API::Request.valid?.should == true
   end
 
-  it "provides connect config validation" do
-    command.stub(:config_dir).and_return(tmpdir)
-
-    # raise for no config
-    expect { command.require_connect_config! }.to raise_error
-
-    config = Mode::Connector::Config.init(tmpdir)
-
-    config.data_sources << Mode::Connector::DataSource.new('test', {})
-    config.save
+  it 'validates a configuration' do
+    command.should_receive(:require_config!)
+    command.should_receive(:require_credentials!)
+    command.should_receive(:configure_api_requests!)
 
-    command.require_connect_config!
+    command.validate_config!
   end
 end

data/spec/commands/import_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 
 describe Mode::Commands::Import do
   let(:tmpdir) { Dir.mktmpdir }
+  let(:config) { Mode::Config.init(tmpdir) }
   let(:packages_path) { Mode::API::Request.packages_path }
   
   before do
@@ -129,6 +130,8 @@ describe Mode::Commands::Import do
       import_params = { 'table_name' => 'espn_draft' }
       import.should_receive(:parse_uploaded_response).with(:package).and_return(resource)
       import.should_receive(:submit_import_form).with(resource, import_params).and_return(true)
+      
+      import.should_receive(:validate_config!).and_return(true)
 
       import.execute
     end
@@ -149,6 +152,8 @@ describe Mode::Commands::Import do
       import.should_receive(:parse_uploaded_response).with(:package).and_return(resource)
       import.should_receive(:submit_import_form).with(resource, import_params).and_return(true)
 
+      import.should_receive(:validate_config!).and_return(true)
+
       import.execute
     end
   end

data/spec/commands/login_spec.rb

@@ -5,57 +5,42 @@ describe Mode::Commands::Login do
   let(:username) { 'besquared' }
   let(:password) { 'password' }
 
-  let(:personal_repr) {
+  let(:token_repr) {
     {
       'name' => 'personal',
       'token' => 'token123',
-      'account_name' => 'besquared'
+      'password' => 'password123',
+      'account_name' => 'besquared',
+      '_links' => {
+        'verify' => {
+          'href' => 'verification_url{?password}'
+        }
+      }
     }
   }
 
-  let(:secondary_repr) {
-    {
-      'name' => 'secondary',
-      'token' => 'token567',
-      'account_name' => 'besquared'
-    }
+
+  let(:token_resource) {
+    Mode::API::Resource.new(token_repr)
   }
 
-  let(:tokens_resource) {
-    Mode::API::Resource.new({
-      '_embedded' => {
-        'access_tokens' => [
-          personal_repr,
-          secondary_repr
-        ]
-      }
-    })
+  let(:token) {
+    Mode::Auth::AccessToken.new(token_resource)
   }
 
-  let(:single_tokens_resource) {
+  let(:tokens_resource) {
     Mode::API::Resource.new({
       '_embedded' => {
-        'access_tokens' => [
-          personal_repr
-        ]
+        'access_tokens' => [token_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)
-    )
-  }
+  let(:command) { Mode::Commands::Login.new(:test => true) }
 
   before do
     initialize_logger
+    command.stub(:say)
   end
 
   it "initializes with each environment" do
@@ -65,65 +50,52 @@ describe Mode::Commands::Login do
   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.should_receive(:choose_access_token).and_return(token)
 
     command.execute
 
     config = Mode::Config.new(tmpdir)
 
     config.username.should == 'besquared'
-    config.access_token.should == 'token123'
+    config.access_token['token'].should == 'token123'
+    config.access_token['password'].should == 'password123'
   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.should_receive(:choose_access_token).and_return(token)
 
     command.execute
 
     config = Mode::Config.new(tmpdir)
 
     config.username.should == 'besquared'
-    config.access_token.should == 'token123'
+    config.access_token['token'].should == 'token123'
+    config.access_token['password'].should == 'password123'
   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')
 
@@ -134,46 +106,85 @@ describe Mode::Commands::Login do
   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)
+    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)
+  it "fetches access tokens" do
+    Mode::API::Request.should_receive(:get).with(
+      :access_tokens).and_return(tokens_resource)
+
+    command.send(:fetch_access_tokens).first.token.should == 'token123'
+  end
 
-    tokens = command.send(:fetch_access_tokens)
+  it "creates a new access token" do
+    Mode::API::Request.should_receive(:post).with(:access_tokens, {
+      :access_token => { :name => "Token Name" } }).and_return(token_resource)
 
-    tokens.length.should == 2
-    tokens.first.token.should == 'token123'
-    tokens.last.token.should == 'token567'
+    command.should_receive(:ask).and_return("Token Name")
+    command.send(:create_access_token).token.should == 'token123'
   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)
+  it "verifies an access token password with success" do
+    Mode::API::Request.should_receive(:get).with(
+      'verification_url?password=password').and_return(token_resource)
+
+    command.send(:verify_access_token, token, 'password').token.should == token.token
+  end
 
-    command.should_not_receive(:ask)
+  describe "when there are no access tokens" do
+    it "prompts the user to create an access token" do
+      command.should_receive(:fetch_access_tokens).and_return([])
+      command.should_receive(:prompt_create_access_token).and_return(token)
+      command.send(:choose_access_token).should == token
+    end
 
-    chosen_token = command.send(:choose_access_token)
+    it "creates a new token upon user request" do
+      command.should_receive(:yes?).and_return(true)
+      command.should_receive(:create_access_token).and_return(token)
+      command.send(:prompt_create_access_token).token.should == 'token123'
+    end
 
-    chosen_token.should_not == nil
-    chosen_token.token.should == 'token123'
+    it "raises an error if the user doesn't create a token" do
+      command.should_receive(:yes?).and_return(false)
+      expect { command.send(:prompt_create_access_token) }.to raise_error
+    end
   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)
+  describe "when there are one or more access tokens" do
+    it "prompts the user to choose an access token" do
+      command.should_receive(:fetch_access_tokens).and_return([token])
+      command.should_receive(:prompt_choose_access_token).with([token]).and_return(token)
+      command.send(:choose_access_token).should == token
+    end
 
-    command.stub(:say)
-    command.should_receive(:ask).and_return("2")
+    it "asks the user to make a token choice" do
+      command.should_receive(:ask).and_return("2")
+      command.should_receive(:ask).and_return("1")
+      command.send(:ask_for_access_token_choice, [token]).should == "1"
+    end
 
-    chosen_token = command.send(:choose_access_token)
+    it "verifies the chosen access token" do
+      command.should_receive(:ask).and_return(:fake)
+      command.should_receive(:ask).and_return(:secret)
+      command.should_receive(:verify_access_token).with(token, :fake).and_return(false)
+      command.should_receive(:verify_access_token).with(token, :secret).and_return(true)
+      command.send(:verify_access_token_secret, token).should == true
+    end
 
-    chosen_token.should_not == nil
-    chosen_token.token.should == 'token567'
+    it "verifies the access token after prompted choice" do
+      command.should_receive(:ask_for_access_token_choice).and_return("1")
+      command.should_receive(:verify_access_token_secret).and_return(token)
+      command.send(:prompt_choose_access_token, [token]).should == token
+    end
+
+    it "creates a new token if the user skips token choice" do
+      command.should_receive(:ask_for_access_token_choice).and_return("")
+      command.should_receive(:create_access_token).and_return(token)
+      command.send(:prompt_choose_access_token, [token]).should == token
+    end
   end
 end