ey_cli 0.1.0

data/lib/ey_cli/smarty_parser.rb

@@ -0,0 +1,29 @@
+module EYCli
+  module SmartyParser
+    def parse(body, klass = self)
+      case body
+      when Hash
+        klass.new smarty(body)
+      when Array
+        body.map { |item| parse(item, klass) }
+      else
+        body
+      end
+    end
+
+    def smarty(hash)
+      hash.each do |key, value|
+        case key
+        when /accounts?/
+          hash[key] = parse(value, EYCli::Model::Account)
+        when /apps?/
+          hash[key] = parse(value, EYCli::Model::App)
+        when /environments?/
+          hash[key] = parse(value, EYCli::Model::Environment)
+        else
+          hash[key] = parse(value, Hashie::Mash)
+        end
+      end
+    end
+  end
+end

data/lib/ey_cli/term.rb

@@ -0,0 +1,58 @@
+module EYCli
+  class Term
+    require 'highline'
+
+    attr_reader :terminal
+
+    def initialize(input = $stdin, output = $stdout)
+      HighLine.color_scheme = HighLine::SampleColorScheme.new
+      @terminal = HighLine.new(input, output)
+    end
+
+    def choose_resource(collection, message, prompt)
+      say(message)
+
+      terminal.choose do |menu|
+        menu.index = :number
+        menu.index_suffix = ' ~> '
+        menu.prompt = prompt
+
+        collection.each do |resource|
+          menu.choice resource.name
+        end
+      end
+    end
+
+    def say(message)
+      terminal.say(message)
+    end
+
+    def error(message)
+      terminal.say(%Q{<%= color("#{message}", :error)%>})
+    end
+
+    def warning(message)
+      terminal.say(%Q{<%= color("#{message}", :warning)%>})
+    end
+
+    def success(message)
+      terminal.say(%Q{<%= color("#{message}", :debug)%>})
+    end
+
+    def print_errors(errors, message)
+      error(message)
+      errors.each do |key, value|
+        alert = value.respond_to?(:join) ? value.join(',') : value.inspect
+        error("\t- #{key}: #{alert}")
+      end
+    end
+
+    def ask(prompt, protected_filed = false)
+      if protected_filed
+        terminal.ask(prompt) {|q| q.echo = '*'}
+      else
+        terminal.ask(prompt) {|q| q.readline = true}
+      end
+    end
+  end
+end

data/lib/ey_cli.rb

@@ -0,0 +1,46 @@
+module EYCli
+  VERSION = '0.1.0'
+
+  require 'hashie/mash'
+  require 'json'
+  require 'multi_json'
+
+  require 'ey_cli/api'
+  require 'ey_cli/cli'
+  require 'ey_cli/git_utils'
+  require 'ey_cli/command_manager'
+  require 'ey_cli/options_parser'
+  require 'ey_cli/smarty_parser'
+  require 'ey_cli/term'
+
+  require 'ey_cli/models/base'
+  require 'ey_cli/models/account'
+  require 'ey_cli/models/app'
+  require 'ey_cli/models/environment'
+
+  require 'ey_cli/controllers/accounts'
+  require 'ey_cli/controllers/apps'
+  require 'ey_cli/controllers/environments'
+
+  require 'ey_cli/commands/base'
+  require 'ey_cli/commands/accounts'
+  require 'ey_cli/commands/apps'
+  require 'ey_cli/commands/console'
+  require 'ey_cli/commands/create_app'
+  require 'ey_cli/commands/create_env'
+  require 'ey_cli/commands/deploy'
+  require 'ey_cli/commands/help'
+  require 'ey_cli/commands/show'
+
+  def self.api(endpoint = nil)
+    @api ||= Api.new(endpoint)
+  end
+
+  def self.term(input = $stdin, output = $stdout)
+    @ui ||= Term.new(input, output)
+  end
+
+  def self.command_manager
+    @command_manager ||= EYCli::CommandManager.new
+  end
+end

data/spec/auth_helper.rb

@@ -0,0 +1,28 @@
+module EYCli
+  module AuthHelper
+    def self.extended(example_group)
+      example_group.use_credentials(example_group)
+    end
+
+    def self.included(example_group)
+      example_group.extend self
+    end
+
+    def mock_credentials
+  rc = File.expand_path('../fake_rc', __FILE__)
+
+  File.open(rc, 'w') do |f| f.write <<-EOF
+---
+  api_token: fake_token
+EOF
+  end
+  ENV['EYRC'] = rc
+end
+
+    def use_credentials(describe_block)
+      describe_block.before :each do
+        mock_credentials
+      end
+    end
+  end
+end

data/spec/ey_cli/api_spec.rb

@@ -0,0 +1,70 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+
+describe EYCli::Api do
+  subject { EYCli::Api.new('http://example.com') }
+
+  context "reading the auth token from the file" do
+    it "returns nil if the file doesn't exist" do
+      subject.read_token('fake_file').should be_nil
+    end
+
+    it "returns nil if the file is empty" do
+      File.open('fake_file', 'w')
+      subject.read_token('fake_file').should be_nil
+    end
+
+    it "returns the token in the root if there is no token for the endpoint" do
+     File.open('fake_file', 'w') do |f| 
+      f.write <<-EOF
+---
+  api_token: root_api_token
+EOF
+    end
+
+     subject.read_token('fake_file').should == 'root_api_token'
+    end
+
+    it "returns the token for the endpoint if exists" do
+     File.open('fake_file', 'w') do |f| 
+      f.write <<-EOF
+---
+  api_token: root_api_token
+  http://example.com:
+    api_token: example_com_api_token
+EOF
+    end
+
+     subject.read_token('fake_file').should == 'example_com_api_token'
+    end
+  end
+
+  context "saving the auth token" do
+    def fake_rc_file
+      File.read('fake_file').gsub(/\s*/m, '')
+    end
+
+    it "stores the token under the enpoint" do
+      subject.save_token('new_token', 'fake_file')
+      fake_rc_file.should == '---http://example.com:api_token:new_token'
+    end
+
+    it "adds it to the file if already existed" do
+      File.open('fake_file', 'w') {|f| f.write("---\n  api_token: root_token") }
+      subject.save_token('new_token', 'fake_file')
+      fake_rc_file.should == '---api_token:root_tokenhttp://example.com:api_token:new_token'
+    end
+  end
+
+  context "fetching the token from the terminal" do
+    it "sends the user credentials to the api" do
+      EYCli.term.should_receive(:ask).with('Email: ').and_return('foo@foo.com')
+      EYCli.term.should_receive(:ask).with('Password: ', true).and_return('fooooo')
+
+      stub_request(:post, "http://example.com/authenticate?email=foo@foo.com&password=fooooo").
+         to_return(:status => 200, :body => to_json(:api_token => 'foo_token'))
+
+      ENV['EYRC'] = 'fake_file'
+      subject.fetch_token.should == 'foo_token'
+    end
+  end
+end

data/spec/ey_cli/command_manager_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+
+module EYCli::Command
+  class MockCommand; end
+end
+
+describe EYCli::CommandManager do
+  before { subject.register_command(:mock_command) }
+
+  it "registers commands" do
+    subject.commands.keys.should include(:mock_command)
+  end
+
+  it "returns nil if the command class is not registered" do
+    subject[:bar].should be_nil
+  end
+
+  it "returns an instance of the command class if it's registered" do
+    subject[:mock_command].should be_instance_of(EYCli::Command::MockCommand)
+  end
+
+  it "returns nil if the command class is not defined" do
+    subject.register_command(:bar)
+    subject[:bar].should be_nil
+  end
+
+  it "only loads the command class once" do
+    subject.should_receive(:load_command).
+            with(:mock_command).
+            once.and_return(EYCli::Command::MockCommand.new)
+    subject[:mock_command] || subject[:mock_command]
+  end
+end

data/spec/ey_cli/commands/help_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+class EYCli::Command::WithoutHelp; def help; end end
+class EYCli::Command::WithHelp; def help; 'run with_help' end end
+
+describe EYCli::Command::Help do
+  before do
+    EYCli.command_manager.register_command :without_help
+    EYCli.command_manager.register_command :with_help
+  end
+
+  it "prints the global help when the command name is not provided" do
+    subject.run([])
+    $stdout_test.string.should =~ /ey_cli help commands/
+  end
+
+  it "says that the help is not available when the command does not exist" do
+    subject.run(['fake_command'])
+    $stdout_test.string.should =~ /help not available/
+  end
+
+  it "says that the help is not available when the command does not have any help message" do
+    subject.run(['without_help'])
+    $stdout_test.string.should =~ /help not available for command: 'without_help'/
+  end
+
+  it "shows the available commands" do
+    subject.run(['commands'])
+    $stdout_test.string.should =~ /available commands/
+  end
+
+  it "shows the help message for the specified command" do
+    subject.run(['with_help'])
+    $stdout_test.string.should =~ /run with_help/
+  end
+end

data/spec/ey_cli/controllers/accounts_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe EYCli::Controller::Accounts do
+  it "returns the first account if we don't provide a name and the user has only one account" do
+    expected = EYCli::Model::Account.new({:id => 1, :name => 'foo'})
+    stub_request(:get, 'http://example.com/accounts').
+      to_return(:status => 200, :body => to_json({'accounts' => [expected]}))
+
+    account = subject.fetch_account
+    account.should == expected
+  end
+
+  it "returns nil if we don't find the account by the name provided" do
+    expected = EYCli::Model::Account.new({:id => 1, :name => 'foo'})
+    stub_request(:get, 'http://example.com/accounts').
+      to_return(:status => 200, :body => to_json({'accounts' => [expected]}))
+
+    subject.fetch_account('bar').should be_nil
+  end
+
+  it "returns nil if the user hasn't created an account yet" do
+    stub_request(:get, 'http://example.com/accounts').
+      to_return(:status => 200, :body => to_json({'accounts' => []}))
+
+    subject.fetch_account.should be_nil
+  end
+
+  it "returns the account selected by the user" do
+    account1 = EYCli::Model::Account.new({:id => 1, :name => 'foo'})
+    account2 = EYCli::Model::Account.new({:id => 2, :name => 'bar'})
+    account3 = EYCli::Model::Account.new({:id => 3, :name => 'baz'})
+    stub_request(:get, 'http://example.com/accounts').
+      to_return(:status => 200, :body => to_json({'accounts' => [account1, account2, account3]}))
+
+    EYCli.term.terminal.should_receive(:choose).and_return('bar')
+
+    account = subject.fetch_account
+    account.should == account2
+  end
+end

data/spec/ey_cli/controllers/apps_spec.rb

@@ -0,0 +1,97 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe EYCli::Controller::Apps do
+  before { Dir.mkdir('fake_app') }
+  let(:account) { EYCli::Model::Account.new(:id => 1) }
+
+  it "shows an error message when the directory is not a git repository" do
+    EYCli.term.should_receive(:error).with('Not a git repository: fake_app')
+    subject.create(account, 'fake_app')
+  end
+
+  context 'trying to figure out the application type' do
+    it "uses rails 3 as default" do
+      subject.fetch_type('fake_app').should == :rails3
+    end
+
+    it 'is a rails 3 app if the directory has the environment and rackup files' do
+      Dir.mkdir('fake_app/config')
+      ['fake_app/config.ru', 'fake_app/config/environment.rb'].each {|f| File.open(f, 'w')}
+
+      subject.fetch_type('fake_app').should == :rails3
+    end
+
+    it 'is a rails 2 app if the directory only includes the environment file' do
+      Dir.mkdir('fake_app/config')
+      File.open('fake_app/config/environment.rb', 'w')
+      subject.fetch_type('fake_app').should == :rails2
+    end
+
+    it 'is a rack app if the directory only includes the rackup file' do
+      File.open('fake_app/config.ru', 'w')
+      subject.fetch_type('fake_app').should == :rack
+    end
+  end
+
+  context 'under a git repository' do
+    before { Dir.mkdir('fake_app/.git') }
+    let(:success_params) do
+      {
+        :account => account,
+        'app[name]' => 'fake_app',
+        'app[app_type_id]' => 'rails3',
+        'app[repository_uri]' => 'git@git.com:foo/bar.git'
+      }
+    end
+
+    it 'shows an error if the model cannot create the application' do
+      app_with_errors = EYCli::Model::App.new({:errors => {:name => 'bad_name'}})
+      EYCli.term.should_receive(:print_errors).with(app_with_errors.errors, 'App creation failed:')
+      EYCli::Model::App.should_receive(:create).and_return(app_with_errors)
+
+      subject.create(account, 'fake_app')
+    end
+
+    it "shows a success message when the model creates the app" do
+      app = EYCli::Model::App.new({:id => 1, :name => 'fake_app'})
+      EYCli::Model::App.should_receive(:create).with(success_params).and_return(app)
+      EYCli.term.should_receive(:success)
+      subject.should_receive(:fetch_repository).and_return('git@git.com:foo/bar.git')
+
+      subject.create(account, 'fake_app')
+    end
+  end
+
+  context '#fetch_app' do
+    let(:app1) { EYCli::Model::App.new(:id => 1, :repository_uri => 'git@foo.com', :name => 'foo_app') }
+    let(:app2) { EYCli::Model::App.new(:id => 2, :repository_uri => 'git@bar.com', :name => 'bar_app') }
+
+    it 'returns the first app if the user only has one' do
+      stub_request(:get, 'http://example.com/apps').
+        to_return(:status => 200, :body => to_json(:apps => [app1]))
+      subject.fetch_app.should == app1
+    end
+
+    it 'returns the first app that matches the name passed as an option' do
+      stub_request(:get, 'http://example.com/apps').
+        to_return(:status => 200, :body => to_json(:apps => [app1, app2]))
+      subject.fetch_app(nil, {:app_name => 'bar_app'}).should == app2
+    end
+
+    it 'returns the first app that matches the git repository uri of the base path' do
+      stub_request(:get, 'http://example.com/apps').
+        to_return(:status => 200, :body => to_json(:apps => [app1, app2]))
+      subject.should_receive(:git_repository?).and_return(true)
+      subject.should_receive(:fetch_repository).and_return('git@bar.com')
+
+      subject.fetch_app.should == app2
+    end
+
+    it 'returns the app according to the option the user chooses' do
+      stub_request(:get, 'http://example.com/apps').
+        to_return(:status => 200, :body => to_json(:apps => [app1, app2]))
+      EYCli.term.should_receive(:choose_resource).and_return('bar_app')
+      subject.fetch_app.should == app2
+    end
+  end
+end

data/spec/ey_cli/controllers/environments_spec.rb

@@ -0,0 +1,101 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe EYCli::Controller::Environments do
+  let(:app) { EYCli::Model::App.new(:id => 1, :name => 'fake_app') }
+
+  context 'creating a new environment' do
+    let(:success_params) do
+      {
+        :app                         => app,
+        'environment[name]'          => "#{app.name}_production",
+        'environment[framework_env]' => 'production',
+      }
+    end
+
+    it "shows an error message if the model cannot create the environment" do
+      env_with_errors = EYCli::Model::Environment.new({:errors => {:name => 'bad_name'}})
+      EYCli.term.should_receive(:print_errors).with(env_with_errors.errors, 'Environment creation failed:')
+      EYCli::Model::Environment.should_receive(:create).and_return(env_with_errors)
+
+      subject.create(app, {})
+    end
+
+    it "shows a success message when the model creates the app" do
+      env = EYCli::Model::Environment.new({:id => 1, :name => 'fake_app_production', :framework_env => 'production'})
+      EYCli::Model::Environment.should_receive(:create).with(success_params).and_return(env)
+      EYCli.term.should_receive(:success)
+
+      response = subject.create(app, {})
+      response.should == env
+    end
+
+    it "allows to specify the framework environment as a parameter" do
+      params = success_params.merge({'environment[name]' => 'fake_app_staging', 'environment[framework_env]' => 'staging'})
+      env = EYCli::Model::Environment.new({:id => 1, :name => 'fake_app_staging', :framework_env => 'staging'})
+      EYCli::Model::Environment.should_receive(:create).with(params).and_return(env)
+      EYCli.term.should_receive(:success)
+
+      response = subject.create(app, {:framework_env => 'staging'})
+      response.should == env
+    end
+
+    it "allows to specify the environment name" do
+      params = success_params.merge({'environment[name]' => 'fake_environment_name', 'environment[framework_env]' => 'production'})
+      env = EYCli::Model::Environment.new({:id => 1, :name => 'fake_environment_name', :framework_env => 'production'})
+      EYCli::Model::Environment.should_receive(:create).with(params).and_return(env)
+      EYCli.term.should_receive(:success)
+
+      response = subject.create(app, {:name => 'fake_environment_name'})
+      response.should == env
+    end
+
+    context "with cluster options" do
+      it "is pending"
+    end
+  end
+
+  context "deploying an environment" do
+    it "shows an error if the application doesn't have any environment" do
+      EYCli.term.should_receive(:error)
+      subject.deploy(app)
+    end
+
+    context "when the app has only one environment" do
+      before do
+        @env = mock
+        app[:environments] = [@env]
+      end
+
+      it "uses the environment without asking" do
+        @env.should_receive(:deploy).and_return(Hashie::Mash.new)
+        EYCli.term.should_not_receive(:choose_resource)
+        subject.deploy(app)
+      end
+
+      it "shows the error list when the deploy fails" do
+        expected = Hashie::Mash.new({:errors => {:provision => 'Amazon cannot provision the instance'}})
+        @env.should_receive(:deploy).and_return(expected)
+        EYCli.term.should_receive(:print_errors).with(expected.errors, "Application deployment failed:")
+        subject.deploy(app)
+      end
+
+      it "shows the success message if it doesn't return any error" do
+        @env.should_receive(:deploy).and_return(Hashie::Mash.new)
+        EYCli.term.should_receive(:success)
+        subject.deploy(app)
+      end
+    end
+
+    context "when the app has more than one environment" do
+      it "shows the environments' list to let the user choose" do
+        env1 = EYCli::Model::Environment.new(:name => 'mock1')
+        env2 = mock
+        env2.should_receive(:name).and_return('mock2')
+        env2.should_receive(:deploy).and_return(Hashie::Mash.new)
+        app[:environments] = [env1, env2]
+        EYCli.term.should_receive(:choose_resource).and_return('mock2')
+        subject.deploy(app)
+      end
+    end
+  end
+end

data/spec/ey_cli/models/app_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path('../../spec_helper', File.dirname(__FILE__))
+
+describe EYCli::Model::App do
+  context ".create" do
+    it "return an error if it doesn't find the account" do
+      app = EYCli::Model::App.create({})
+      app.errors?.should be_true
+      app.errors.keys.should include('account')
+    end
+
+    it "return an error if a model validation fails" do
+      account = EYCli::Model::Account.new({:id => 1})
+      stub_request(:post, 'http://example.com/accounts/1/apps?app[name]=foo').
+        to_return(:status => 422, :body => to_json({:errors => {:name => ['App name already exists']}}))
+
+      app = EYCli::Model::App.create({:account => account, 'app[name]' => 'foo'})
+      app.errors?.should be_true
+      app.errors.keys.should include('name')
+    end
+
+    it "returns the new app when it's successful" do
+      account = EYCli::Model::Account.new({:id => 1})
+      expected = EYCli::Model::App.new({:id => 1, :name => 'foo'})
+      stub_request(:post, 'http://example.com/accounts/1/apps?app[name]=foo').
+        to_return(:status => 201, :body => to_json(:app => expected))
+
+      app = EYCli::Model::App.create({:account => account, 'app[name]' => 'foo'})
+      app.should == expected
+    end
+
+    context '.find_by_repository_uri' do
+      let(:app1) { EYCli::Model::App.new(:id => 1, :repository_uri => 'git@foo.com') }
+      let(:app2) { EYCli::Model::App.new(:id => 2, :repository_uri => 'git@bar.com') }
+      before do
+        stub_request(:get, 'http://example.com/apps').
+          to_return(:status => 200, :body => to_json(:apps => [app1, app2]))
+      end
+
+      it "returns an instance of App if it finds it" do
+        app = EYCli::Model::App.find_by_repository_uri('git@bar.com')
+        app.should == app2
+      end
+
+      it "returns nil when it cannot find the app" do
+        app = EYCli::Model::App.find_by_repository_uri('foo@bar.com')
+        app.should be_nil
+      end
+    end
+  end
+end