mode 0.0.5 → 0.0.7

data/spec/api/resource_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Mode::API::Resource do
+  let(:links) {
+    {
+      'self' => {
+        'templated' => true,
+        'href' => '/path/to/thing'
+      }
+    }
+  }
+
+  let(:forms) {
+    {
+      'create' => {
+        'method' => 'post',
+        'action' => '/widgets',
+        'input' => {
+          'widgets' => {
+            'type' => 'text',
+            'value' => '500'
+          }
+        }
+      }
+    }
+  }
+
+  let(:embedded) {
+    {
+      'messages' => [{}],
+      'account' => {}
+    }
+  }
+
+  let(:content) {
+    {
+      'thing' => 'value',
+      '_links' => links,
+      '_forms' => forms,
+      '_embedded' => embedded
+    }
+  }
+  
+  before do
+    initialize_logger
+  end
+
+  it "initializes with content" do
+    resource = Mode::API::Resource.new(content)
+
+    resource.thing.should == 'value'
+
+    expect { resource.thing2 }.to raise_error
+
+    link = resource.links('self')
+    link.href.should == links['self']['href']
+
+    form = resource.forms('create')
+    form.action.should == forms['create']['action']
+
+    messages = resource.embedded('messages')
+    messages.length.should == 1
+    messages.first.should be_instance_of(Mode::API::Resource)
+    messages.first.content.should == embedded['messages'].first
+
+    account  = resource.embedded('account')
+    account.should be_instance_of(Mode::API::Resource)
+    account.content.should == embedded['account']
+  end
+end

data/spec/auth/access_token_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Mode::Auth::AccessToken do
+  let(:resource) {
+    Mode::API::Resource.new({
+      'name' => 'Personal',
+      'token' => 'token123',
+      'account_name' => 'besquared'
+    })
+  }
+  
+  before do
+    initialize_logger
+  end
+
+  it "initializes with resource" do
+    token = Mode::Auth::AccessToken.new(resource)
+    token.name.should == 'Personal'
+    token.token.should == 'token123'
+    token.account_name.should == 'besquared'
+  end  
+end

data/spec/commands/analyze_field_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Mode::Commands::AnalyzeField do
+  let(:tmpdir) { Dir.mktmpdir }
+
+  before do
+    initialize_logger
+  end
+
+  it "should analyze a csv" do
+    path = fixture_path('espn_draft.csv')
+    command = Mode::Commands::AnalyzeField.new(path, 1)
+
+    command.stub(:puts).and_return(true)
+
+    command.execute
+  end
+
+  it "should error out if the csv file doesn't exist" do
+    command = Mode::Commands::AnalyzeField.new("fake.yml", 1)
+
+    command.should_receive(:puts)
+
+    command.execute
+  end
+end

data/spec/commands/analyze_schema_spec.rb

@@ -1,15 +1,17 @@
 require 'spec_helper'
 
 describe Mode::Commands::AnalyzeSchema do
-  before(:each) do
-    @tmpdir = Dir.mktmpdir
+  let(:tmpdir) { Dir.mktmpdir }
+
+  before do
+    initialize_logger
   end
 
   it "should analyze a csv" do
-    path = data_path('espn_draft.csv')
+    path = fixture_path('espn_draft.csv')
     command = Mode::Commands::AnalyzeSchema.new(path)
 
-    command.stub(:say).and_return(true)
+    command.stub(:puts).and_return(true)
 
     command.execute
   end
@@ -17,7 +19,7 @@ describe Mode::Commands::AnalyzeSchema do
   it "should error out if the csv file doesn't exist" do
     command = Mode::Commands::AnalyzeSchema.new("fake.yml", keys: [0,1])
 
-    command.should_not_receive(:say)
+    command.should_receive(:puts)
 
     command.execute
   end

data/spec/commands/connect_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Mode::Commands::Connect do
+  let(:tmpdir) { Dir.mktmpdir }
+  let(:config) { Mode::Connector::Config.init(tmpdir) }
+  
+  before 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
+    connect.configuration.should_not == nil
+  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')
+
+    Mode::Connector::Daemon.should_receive(:spawn!).twice.and_return(true)
+
+    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)
+
+    connect.send(:spawn!)
+  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
+  end
+
+  it 'executes the connector' do
+    connect = Mode::Commands::Connect.new('start')
+
+    connect.should_receive(:register!)
+    connect.should_receive(:spawn!)
+
+    connect.execute
+  end
+end

data/spec/commands/helpers_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+class CommandClass
+  include Mode::Commands::Helpers
+end
+
+describe Mode::Commands::Helpers do
+  let(:tmpdir) { Dir.mktmpdir }
+  let(:command) { CommandClass.new }
+
+  before do
+    initialize_logger
+  end
+
+  it "provides a config dir" 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)
+
+    expect { command.require_config! }.to raise_error
+
+    config = Mode::Config.init(tmpdir)
+
+    command.require_config!
+  end
+
+  it "provides credential validation" do
+    command.stub(:config_dir).and_return(tmpdir)
+
+    # 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
+
+    config.username = 'besquared'
+    config.access_token = 'access_token'
+    config.save
+
+    command.require_credentials!
+  end
+
+  it "provides api request configuration" do
+    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
+
+    command.require_connect_config!
+  end
+end

data/spec/commands/import_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+describe Mode::Commands::Import do
+  let(:tmpdir) { Dir.mktmpdir }
+  let(:packages_path) { Mode::API::Request.packages_path }
+  
+  before do
+    initialize_logger
+  end
+
+  it "generates target resource path with a csv extension" do
+    source = fixture_path("espn_draft/data.csv")
+    path = Mode::Commands::Import.send(:target_resource_path, source)
+
+    path.should == "data/index.csv"
+  end
+
+  it "generates target resource path with a non-csv extension" do
+    source = fixture_path("espn_draft.json")
+    path = Mode::Commands::Import.send(:target_resource_path, source)
+
+    path.should == "data/index.json"
+  end
+
+  describe 'finding a package from a source file' do
+    it 'returns the package if the file is adjacent to datapackage.json' do
+      source = fixture_path("espn_draft/data.csv")
+      package = Mode::Commands::Import.find_package(source)
+
+      package.base_path.should == fixture_path("espn_draft")
+    end
+
+    it 'returns the package if the file is inside of the data subdirectory' do
+      source = fixture_path("country-codes/data/country-codes.csv")
+      package = Mode::Commands::Import.find_package(source)
+
+      package.base_path.should == fixture_path("country-codes")
+    end
+
+    it 'returns nil if a package is not found' do
+      source = fixture_path("espn_draft.csv")
+      Mode::Commands::Import.find_package(source).should == nil
+    end
+  end
+
+  describe 'finding a package from a source directory' do
+    it 'returns the package if it exists in the directory' do
+      source = fixture_path("espn_draft")
+      package = Mode::Commands::Import.find_package(source)
+
+      package.base_path.should == fixture_path("espn_draft")
+    end
+
+    it 'returns nil if the package is not found in the directory' do
+      source = fixture_path
+
+      Mode::Commands::Import.find_package(source).should == nil
+    end
+  end
+
+  describe 'building a package from a source file' do
+    it 'build the package' do
+      source = fixture_path("espn_draft.csv")
+      package = Mode::Commands::Import.build_package(source, :dest => tmpdir)
+
+      package.base_path.should == tmpdir
+    end
+
+    it 'returns nil if the file does not exist' do
+      source = fixture_path('nope')
+      Mode::Commands::Import.build_package(source).should == nil
+    end
+  end
+
+  describe 'finding or building a package from a source file' do
+    it 'returns the package and resource name for a file in a datapackage' do
+      source = fixture_path("espn_draft/data.csv")
+      package = Mode::Commands::Import.find_or_build_package(source)
+
+      package.resources.first.path.should == 'data.csv'
+      package.base_path.should == fixture_path("espn_draft")
+    end
+
+    it 'returns the package and resource name for a file outisde a datapackage' do
+      source = fixture_path("espn_draft.csv")
+      package = Mode::Commands::Import.find_or_build_package(source, :dest => tmpdir)
+
+      package.base_path.should == tmpdir
+      package.resources.first.path.should == 'data/index.csv'
+    end
+  end
+
+  describe 'finding or building a package from a source directory' do
+    it 'returns the package and resource name' do
+      source = fixture_path("espn_draft")
+      package = Mode::Commands::Import.find_or_build_package(source, :dest => tmpdir)
+
+      package.resources.first.path.should == 'data.csv'
+      package.base_path.should == fixture_path("espn_draft")
+    end
+  end
+
+  describe 'uploading a package' do
+    it 'uploads a package' do
+      Mode::API::Request.should_receive(:post).and_return(true)
+
+      source = fixture_path("espn_draft.csv")
+      package = Mode::Commands::Import.find_or_build_package(source, :dest => tmpdir)
+
+      import = Mode::Commands::Import.new(source, 'besquared', 'espn_draft')
+
+      import.upload_package(package).should == true
+    end
+  end
+
+  describe 'executing an import' do
+    it 'finds and upload a package' do
+      Mode::API::Request.should_receive(:post).with(packages_path, :package => {
+        :contents => {
+          'datapackage.json' => an_instance_of(String),
+          'data/index.csv' => an_instance_of(Faraday::UploadIO)
+        }, :name => 'espn_draft'
+      }).and_return(:package)
+
+      source = fixture_path("espn_draft/data.csv")
+      import = Mode::Commands::Import.new(source, 'besquared', 'espn_draft')
+
+      resource = double(:resource)
+      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.execute
+    end
+
+    it 'finds and uploads country codes package' do
+      Mode::API::Request.should_receive(:post).with(packages_path, :package => {
+        :contents => {
+          'datapackage.json' => an_instance_of(String),
+          'data/index.csv' => an_instance_of(Faraday::UploadIO)
+        }, :name => 'country_codes'
+      }).and_return(:package)
+
+      source = fixture_path("country-codes/data/country-codes.csv")
+      import = Mode::Commands::Import.new(source, 'besquared', 'country_codes')
+
+      resource = double(:resource)
+      import_params = { 'table_name' => 'country_codes' }
+      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.execute
+    end
+  end
+end