shelly 0.0.4 → 0.0.5

data/bin/shelly

@@ -1,3 +1,3 @@
 #!/usr/bin/env ruby
-require "shelly/cli"
-Shelly::CLI.start
+require "shelly/cli/main"
+Shelly::CLI::Main.start

data/lib/shelly.rb

@@ -2,6 +2,7 @@ require "rubygems"
 require "thor"
 require "core_ext/object"
 require "shelly/helpers"
+require "shelly/base"
 
 module Shelly
   autoload :Client, "shelly/client"

data/lib/shelly/app.rb

@@ -0,0 +1,39 @@
+require 'erb'
+require 'launchy'
+
+module Shelly
+  class App < Base
+    DATABASE_KINDS = %w(postgresql mongodb redis none)
+    attr_accessor :purpose, :code_name, :databases
+
+    def add_git_remote
+      system("git remote add #{purpose} git@git.shellycloud.com:#{code_name}.git")
+    end
+
+    def generate_cloudfile
+      @email = current_user.email
+      @databases = databases
+      template = File.read("lib/shelly/templates/Cloudfile.erb")
+      cloudfile = ERB.new(template, 0, "%<>-")
+      cloudfile.result(binding)
+    end
+
+    def create_cloudfile
+      content = generate_cloudfile
+      File.open(cloudfile_path, "a+") { |f| f << content }
+    end
+
+    def cloudfile_path
+      File.join(Dir.pwd, "Cloudfile")
+    end
+
+    def self.guess_code_name
+      File.basename(Dir.pwd)
+    end
+
+    def open_billing_page
+      url = "#{shelly.api_url}/apps/#{code_name}/edit_billing?api_key=#{current_user.token}"
+      Launchy.open(url)
+    end
+  end
+end

data/lib/shelly/base.rb

@@ -0,0 +1,13 @@
+module Shelly
+  class Base
+    def current_user
+      @user = User.new
+      @user.load_credentials
+      @user
+    end
+
+    def shelly
+      @shelly ||= Client.new(current_user.email, current_user.password)
+    end
+  end
+end

data/lib/shelly/cli/account.rb

@@ -0,0 +1,56 @@
+require "shelly/user"
+
+module Shelly
+  module CLI
+    class Account < Thor
+      namespace :account
+      include Helpers
+
+      desc "register", "Registers new user account on Shelly Cloud"
+      def register
+        email = ask_for_email
+        password = ask_for_password
+
+        # FIXME: ask user in loop, until he enters valid values
+        if email.blank? or password.blank?
+          say "Email and password can't be blank" and exit 1
+        end
+
+        user = User.new(email, password)
+        user.register
+        if user.ssh_key_exists?
+          say "Uploading your public SSH key from #{user.ssh_key_path}"
+        end
+        say "Successfully registered!"
+        say "Check you mailbox for email confirmation"
+      rescue Client::APIError => e
+        if e.message == "Validation Failed"
+          e.errors.each { |error| say "#{error.first} #{error.last}" }
+        end
+      end
+
+      # Fix for bug with displaying help for subcommands
+      # http://stackoverflow.com/questions/5663519/namespacing-thor-commands-in-a-standalone-ruby-executable
+      def self.banner(task, namespace = true, subcommand = false)
+        "#{basename} #{task.formatted_usage(self, true, subcommand)}"
+      end
+
+      # FIXME: move to helpers
+      no_tasks do
+        def ask_for_email
+          email_question = User.guess_email.blank? ? "Email:" : "Email (#{User.guess_email} - default):"
+          email = ask(email_question)
+          email.blank? ? User.guess_email : email
+        end
+
+        def ask_for_password
+          say "Password: "
+          echo_off
+          password = $stdin.gets.strip
+          echo_on
+          password
+        end
+      end
+    end
+  end
+end

data/lib/shelly/cli/apps.rb

@@ -0,0 +1,65 @@
+require "shelly/app"
+
+module Shelly
+  module CLI
+    class Apps < Thor
+      namespace :apps
+
+      desc "add", "Add new application to Shelly Cloud"
+      def add
+        @app = Shelly::App.new
+        @app.purpose = ask_for_purpose
+        @app.code_name = ask_for_code_name
+        @app.databases = ask_for_databases
+        @app.add_git_remote
+        @app.create_cloudfile
+        @app.open_billing_page
+
+        info_adding_cloudfile_to_repository
+        info_deploying_to_shellycloud
+      end
+
+      no_tasks do
+        def ask_for_purpose
+          purpose = ask("How will you use this system (production - default,staging):")
+          purpose.blank? ? "production" : purpose
+        end
+
+        def ask_for_code_name
+          default_code_name = "#{Shelly::App.guess_code_name}-#{@app.purpose}"
+          code_name = ask("Application code name (#{default_code_name} - default):")
+          code_name.blank? ? default_code_name : code_name
+        end
+
+        def ask_for_databases
+          kinds = Shelly::App::DATABASE_KINDS
+          databases = ask("Which database do you want to use #{kinds.join(", ")} (postgresql - default):")
+          begin
+            databases = databases.split(/[\s,]/)
+            valid = databases.all? { |kind| kinds.include?(kind) }
+            break if valid
+            databases = ask("Unknown database kind. Supported are: #{kinds.join(", ")}:")
+          end while not valid
+
+          databases.empty? ? ["postgresql"] : databases
+        end
+
+        def info_adding_cloudfile_to_repository
+          say("Project is now configured for use with Shell Cloud:")
+          say("You can review changes using")
+          say("  git diff")
+        end
+
+        def info_deploying_to_shellycloud
+          say("When you make sure all settings are correct please issue following commands:")
+          say("  git add .")
+          say('  git commit -m "Application added to Shelly Cloud"')
+          say("  git push")
+          say("Deploy to #{@app.purpose} using:")
+          say("  git push #{@app.purpose} master")
+        end
+      end
+    end
+  end
+end
+

data/lib/shelly/cli/main.rb

@@ -0,0 +1,25 @@
+require "shelly"
+require "thor/group"
+require "shelly/cli/account"
+require "shelly/cli/apps"
+
+module Shelly
+  module CLI
+    class Main < Thor
+      include Thor::Actions
+      register(Account, "account", "account <command>", "Manages your account")
+      register(Apps, "apps", "apps <command>", "Manages your applications")
+
+      map %w(-v --version) => :version
+      desc "version", "Displays shelly version"
+      def version
+        say "shelly version #{Shelly::VERSION}"
+      end
+
+      desc "register", "Registers new user account on Shelly Cloud"
+      def register
+        invoke 'account:register'
+      end
+    end
+  end
+end

data/lib/shelly/client.rb

@@ -28,8 +28,12 @@ module Shelly
       ENV["SHELLY_URL"] || "https://admin.winniecloud.com/apiv2"
     end
 
-    def register_user(email, password)
-      post('/users', :user => {:email => email, :password => password})
+    def register_user(email, password, ssh_key)
+      post("/users", :user => {:email => email, :password => password, :ssh_key => ssh_key})
+    end
+
+    def token
+      get("/token")
     end
 
     def post(path, params = {})
@@ -53,14 +57,16 @@ module Shelly
        "shelly-version" => Shelly::VERSION}
     end
 
+    def http_basic_auth_options
+      @email ? {:username => @email, :password => @password} : {}
+    end
+
     def request_parameters(path, method, params = {})
-      unless @email.blank? or @password.blank?
-        params.merge!(:email => @email, :password => @password)
-      end
       {:method   => method,
        :url      => "#{api_url}#{path}",
        :headers  => headers,
-       :payload  => params.to_json}
+       :payload  => params.to_json
+      }.merge(http_basic_auth_options)
     end
 
     def process_response(response)

data/lib/shelly/templates/Cloudfile.erb

@@ -0,0 +1,20 @@
+<%= @code_name %>:
+  ruby: 1.9.2
+  monitoring_email:
+    - <%= @email %>
+  domains:
+    - <%= @code_name %>.winniecloud.com
+  servers:
+    app1:
+      size: large
+      web:
+        type: thin
+        count: 3
+      clock:
+        type: cron
+    <%- @databases.each_with_index do |kind, index| -%>
+    <%= "#{kind}#{index}" %>:
+      size: large
+      database:
+        type: <%= kind %>
+    <%- end -%>

data/lib/shelly/user.rb

@@ -1,5 +1,5 @@
 module Shelly
-  class User
+  class User < Base
     attr_reader :email, :password
     def initialize(email = nil, password = nil)
       @email = email
@@ -7,16 +7,17 @@ module Shelly
     end
 
     def register
-      client = Client.new
-      client.register_user(email, password)
+      ssh_key = File.read(ssh_key_path) if ssh_key_exists?
+      shelly.register_user(email, password, ssh_key)
       save_credentials
     end
 
-    def self.guess_email
-      @@guess_email ||= IO.popen("git config --get user.email").read.strip
+    def token
+      shelly.token["token"]
     end
 
     def load_credentials
+      return unless credentials_exists?
       @email, @password = File.read(credentials_path).split("\n")
     end
 
@@ -26,6 +27,18 @@ module Shelly
       set_credentials_permissions
     end
 
+    def ssh_key_exists?
+      File.exists?(ssh_key_path)
+    end
+
+    def ssh_key_path
+      File.expand_path("~/.ssh/id_rsa.pub")
+    end
+
+    def self.guess_email
+      @@guess_email ||= IO.popen("git config --get user.email").read.strip
+    end
+
     protected
       def config_dir
         File.expand_path("~/.shelly")

data/lib/shelly/version.rb

@@ -1,3 +1,3 @@
 module Shelly
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/shelly.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency "thor"
   s.add_runtime_dependency "rest-client"
   s.add_runtime_dependency "json"
+  s.add_runtime_dependency "launchy"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/spec/shelly/app_spec.rb

@@ -0,0 +1,93 @@
+require "spec_helper"
+require "shelly/app"
+
+describe Shelly::App do
+  before do
+    FileUtils.mkdir_p("/projects/foo")
+    Dir.chdir("/projects/foo")
+    @app = Shelly::App.new
+    @app.purpose = "staging"
+    @app.code_name = "foo-staging"
+  end
+
+  describe ".guess_code_name" do
+    it "should return name of current working directory" do
+      Shelly::App.guess_code_name.should == "foo"
+    end
+  end
+
+  describe "#add_git_remote" do
+    it "should add git remote with proper name and git repository" do
+      @app.should_receive(:system).with("git remote add staging git@git.shellycloud.com:foo-staging.git")
+      @app.add_git_remote
+    end
+  end
+
+  describe "#generate_cloudfile" do
+    it "should return generated cloudfile" do
+      user = mock(:email => "bob@example.com")
+      @app.stub(:current_user).and_return(user)
+      @app.databases = %w(postgresql mongodb)
+      FakeFS.deactivate!
+      expected = <<-config
+foo-staging:
+  ruby: 1.9.2
+  monitoring_email:
+    - bob@example.com
+  domains:
+    - foo-staging.winniecloud.com
+  servers:
+    app1:
+      size: large
+      web:
+        type: thin
+        count: 3
+      clock:
+        type: cron
+    postgresql0:
+      size: large
+      database:
+        type: postgresql
+    mongodb1:
+      size: large
+      database:
+        type: mongodb
+config
+      @app.generate_cloudfile.should == expected
+    end
+  end
+
+  describe "#create_cloudfile" do
+    before do
+      @app.stub(:generate_cloudfile).and_return("foo-staging:")
+    end
+
+    it "should create file if Cloudfile doesn't exist" do
+      File.exists?("/projects/foo/Cloudfile").should be_false
+      @app.create_cloudfile
+      File.exists?("/projects/foo/Cloudfile").should be_true
+    end
+
+    it "should append content if Cloudfile exists" do
+      File.open("/projects/foo/Cloudfile", "w") { |f| f << "foo-production:\n" }
+      @app.create_cloudfile
+      File.read("/projects/foo/Cloudfile").strip.should == "foo-production:\nfoo-staging:"
+    end
+  end
+
+  describe "#cloudfile_path" do
+    it "should return path to Cloudfile" do
+      @app.cloudfile_path.should == "/projects/foo/Cloudfile"
+    end
+  end
+
+  describe "#open_billing_page" do
+    it "should open browser window" do
+      user = mock(:token => "abc", :email => nil, :password => nil)
+      @app.stub(:current_user).and_return(user)
+      url = "#{@app.shelly.api_url}/apps/foo-staging/edit_billing?api_key=abc"
+      Launchy.should_receive(:open).with(url)
+      @app.open_billing_page
+    end
+  end
+end

data/spec/shelly/{cli_spec.rb → cli/account_spec.rb}

@@ -1,50 +1,44 @@
 require "spec_helper"
-require "shelly/cli"
-require "shelly/user"
+require "shelly/cli/account"
 
-describe Shelly::CLI do
+describe Shelly::CLI::Account do
   before do
+    FileUtils.stub(:chmod)
     @client = mock
-    @cli = Shelly::CLI.new
+    @account = Shelly::CLI::Account.new
     Shelly::Client.stub(:new).and_return(@client)
     $stdout.stub(:puts)
     $stdout.stub(:print)
   end
 
-  describe "#version" do
-    it "should return shelly's version" do
-      $stdout.should_receive(:puts).with("shelly version #{Shelly::VERSION}")
-      @cli.version
-    end
-  end
-
   describe "#register" do
     before do
       Shelly::User.stub(:guess_email).and_return("")
       @client.stub(:register_user)
+      @key_path = File.expand_path("~/.ssh/id_rsa.pub")
     end
 
     it "should ask for email and password" do
       $stdout.should_receive(:print).with("Email: ")
       $stdout.should_receive(:print).with("Password: ")
       fake_stdin(["better@example.com", "secret"]) do
-        @cli.register
+        @account.register
       end
     end
 
     it "should suggest email and use it if user enters blank email" do
       Shelly::User.stub(:guess_email).and_return("kate@example.com")
-      $stdout.should_receive(:print).with("Email (default kate@example.com): ")
-      @client.should_receive(:register_user).with("kate@example.com", "secret")
+      $stdout.should_receive(:print).with("Email (kate@example.com - default): ")
+      @client.should_receive(:register_user).with("kate@example.com", "secret", nil)
       fake_stdin(["", "secret"]) do
-        @cli.register
+        @account.register
       end
     end
 
     it "should use email provided by user" do
-      @client.should_receive(:register_user).with("better@example.com", "secret")
+      @client.should_receive(:register_user).with("better@example.com", "secret", nil)
       fake_stdin(["better@example.com", "secret"]) do
-        @cli.register
+        @account.register
       end
     end
 
@@ -53,7 +47,7 @@ describe Shelly::CLI do
       $stdout.should_receive(:puts).with("Email and password can't be blank")
       lambda do
         fake_stdin(["", "only-pass"]) do
-          @cli.register
+          @account.register
         end
       end.should raise_error(SystemExit)
     end
@@ -62,17 +56,38 @@ describe Shelly::CLI do
       $stdout.should_receive(:puts).with("Email and password can't be blank")
       lambda do
         fake_stdin(["better@example.com", ""]) do
-          @cli.register
+          @account.register
         end
       end.should raise_error(SystemExit)
     end
 
+    context "ssh key exists" do
+      it "should register with ssh-key" do
+        FileUtils.mkdir_p("~/.ssh")
+        File.open(@key_path, "w") { |f| f << "key" }
+        $stdout.should_receive(:puts).with("Uploading your public SSH key from #{@key_path}")
+        fake_stdin(["kate@example.com", "secret"]) do
+          @account.register
+        end
+      end
+    end
+
+    context "ssh key doesn't exist" do
+      it "should register user without the ssh key" do
+        $stdout.should_not_receive(:puts).with("Uploading your public SSH key from #{@key_path}")
+        fake_stdin(["kate@example.com", "secret"]) do
+          @account.register
+        end
+      end
+    end
+
     context "on successful registration" do
       it "should display message about registration and email confirmation" do
         @client.stub(:register_user).and_return(true)
-        $stdout.should_receive(:puts).with("Successfully registered!\nCheck you mailbox for email confirmation")
+        $stdout.should_receive(:puts).with("Successfully registered!")
+        $stdout.should_receive(:puts).with("Check you mailbox for email confirmation")
         fake_stdin(["kate@example.com", "pass"]) do
-          @cli.register
+          @account.register
         end
       end
     end
@@ -84,9 +99,9 @@ describe Shelly::CLI do
         @client.stub(:register_user).and_raise(exception)
         $stdout.should_receive(:puts).with("email has been already taken")
         fake_stdin(["kate@example.com", "pass"]) do
-          @cli.register
+          @account.register
         end
       end
     end
   end
-end
+end

data/spec/shelly/cli/apps_spec.rb

@@ -0,0 +1,128 @@
+require "spec_helper"
+require "shelly/cli/apps"
+
+describe Shelly::CLI::Apps do
+  before do
+    @apps = Shelly::CLI::Apps.new
+    $stdout.stub(:print)
+    $stdout.stub(:puts)
+  end
+
+  describe "#add" do
+    before do
+      FileUtils.mkdir_p("/projects/foo")
+      Dir.chdir("/projects/foo")
+      @app = Shelly::App.new
+      @app.stub(:add_git_remote)
+      @app.stub(:generate_cloudfile).and_return("Example Cloudfile")
+      @app.stub(:open_billing_page)
+      Shelly::App.stub(:new).and_return(@app)
+    end
+
+    it "should ask user how he will use application" do
+      $stdout.should_receive(:print).with("How will you use this system (production - default,staging): ")
+      @app.should_receive(:purpose=).with("staging")
+      fake_stdin(["staging", "", ""]) do
+        @apps.add
+      end
+    end
+
+    context "when user provided empty purpose" do
+      it "should use 'production' as default" do
+        $stdout.should_receive(:print).with("How will you use this system (production - default,staging): ")
+        @app.should_receive(:purpose=).with("production")
+        fake_stdin(["", "", ""]) do
+          @apps.add
+        end
+      end
+    end
+
+    it "should use code name provided by user" do
+      $stdout.should_receive(:print).with("How will you use this system (production - default,staging): ")
+      $stdout.should_receive(:print).with("Application code name (foo-staging - default): ")
+      @app.should_receive(:code_name=).with("mycodename")
+      fake_stdin(["staging", "mycodename", ""]) do
+        @apps.add
+      end
+    end
+
+    context "when user provided empty code name" do
+      it "should use 'current_dirname-purpose' as default" do
+        $stdout.should_receive(:print).with("How will you use this system (production - default,staging): ")
+        $stdout.should_receive(:print).with("Application code name (foo-staging - default): ")
+        fake_stdin(["staging", "", ""]) do
+          @apps.add
+        end
+      end
+    end
+
+    it "should use database provided by user (separated by comma or space)" do
+      $stdout.should_receive(:print).with("Which database do you want to use postgresql, mongodb, redis, none (postgresql - default): ")
+      @app.should_receive(:databases=).with(["postgresql", "mongodb", "redis"])
+      fake_stdin(["staging", "", "postgresql,mongodb redis"]) do
+        @apps.add
+      end
+    end
+
+    it "should validate databases" do
+      $stdout.should_receive(:print).with("Which database do you want to use postgresql, mongodb, redis, none (postgresql - default): ")
+      $stdout.should_receive(:print).with("Unknown database kind. Supported are: postgresql, mongodb, redis, none: ")
+      fake_stdin(["staging", "", "postgresql,doesnt-exist", "none"]) do
+        @apps.add
+      end
+    end
+
+    context "when user provided empty database" do
+      it "should use 'postgresql' database as default" do
+        @app.should_receive(:databases=).with(["postgresql"])
+        fake_stdin(["staging", "", ""]) do
+          @apps.add
+        end
+      end
+    end
+
+    it "should add git remote" do
+      @app.should_receive(:add_git_remote)
+      fake_stdin(["staging", "foooo", ""]) do
+        @apps.add
+      end
+    end
+
+    it "should create Cloudfile" do
+      File.exists?("/projects/foo/Cloudfile").should be_false
+      fake_stdin(["staging", "foooo", ""]) do
+        @apps.add
+      end
+      File.read("/projects/foo/Cloudfile").should == "Example Cloudfile"
+    end
+
+    it "should browser window with link to edit billing information" do
+      @app.should_receive(:open_billing_page)
+      fake_stdin(["staging", "foooo", ""]) do
+        @apps.add
+      end
+    end
+
+    it "should display info about adding Cloudfile to repository" do
+      $stdout.should_receive(:puts).with("Project is now configured for use with Shell Cloud:")
+      $stdout.should_receive(:puts).with("You can review changes using")
+      $stdout.should_receive(:puts).with("  git diff")
+      fake_stdin(["staging", "foooo", "none"]) do
+        @apps.add
+      end
+    end
+
+    it "should display info on how to deploy to ShellyCloud" do
+      $stdout.should_receive(:puts).with("When you make sure all settings are correct please issue following commands:")
+      $stdout.should_receive(:puts).with("  git add .")
+      $stdout.should_receive(:puts).with('  git commit -m "Application added to Shelly Cloud"')
+      $stdout.should_receive(:puts).with("  git push")
+      $stdout.should_receive(:puts).with("Deploy to staging using:")
+      $stdout.should_receive(:puts).with("  git push staging master")
+      fake_stdin(["staging", "foooo", "none"]) do
+        @apps.add
+      end
+    end
+  end
+end
+

data/spec/shelly/cli/main_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+require "shelly/cli/main"
+
+describe Shelly::CLI::Main do
+  before do
+    @main = Shelly::CLI::Main.new
+  end
+
+  describe "#version" do
+    it "should return shelly's version" do
+      $stdout.should_receive(:puts).with("shelly version #{Shelly::VERSION}")
+      @main.version
+    end
+  end
+
+  describe "#register" do
+    it "should invoke account:register command" do
+      @main.should_receive(:invoke).with('account:register')
+      @main.register
+    end
+  end
+
+  describe "#help" do
+    it "should display available commands" do
+      expected = <<-OUT
+Tasks:
+  shelly account <command>  # Manages your account
+  shelly apps <command>     # Manages your applications
+  shelly help [TASK]        # Describe available tasks or one specific task
+  shelly register           # Registers new user account on Shelly Cloud
+  shelly version            # Displays shelly version
+OUT
+      out = IO.popen("bin/shelly").read.strip
+      out.should == expected.strip
+    end
+  end
+end

data/spec/shelly/client_spec.rb

@@ -25,8 +25,16 @@ describe Shelly::Client do
 
   describe "#register_user" do
     it "should send post request with login and password" do
-      @client.should_receive(:post).with("/users", {:user => {:email => "test@example.com", :password => "secret"}})
-      @client.register_user("test@example.com", "secret")
+      @client.should_receive(:post).with("/users", {:user => {:email => "test@example.com",
+        :password => "secret", :ssh_key => "ssh-key Abb"}})
+      @client.register_user("test@example.com", "secret", "ssh-key Abb")
+    end
+  end
+
+  describe "#token" do
+    it "should get authentication token" do
+      @client.should_receive(:get).with("/token")
+      @client.token
     end
   end
 
@@ -36,7 +44,9 @@ describe Shelly::Client do
         :method => :post,
         :url => "#{@client.api_url}/account",
         :headers => @client.headers,
-        :payload => {:name => "bob", :email => "bob@example.com", :password => "secret"}.to_json
+        :payload => {:name => "bob"}.to_json,
+        :username => "bob@example.com",
+        :password => "secret"
       }
       @client.request_parameters("/account", :post, :name => "bob").should == expected
     end
@@ -49,7 +59,7 @@ describe Shelly::Client do
         :headers => @client.headers,
         :payload => {}.to_json
       }
-      client.request("/account", :get)
+      client.request_parameters("/account", :get).should == expected
     end
   end
 

data/spec/shelly/user_spec.rb

@@ -1,10 +1,9 @@
-require "shelly/user"
 require "spec_helper"
 
 describe Shelly::User do
-  include FakeFS::SpecHelpers
-
   before do
+    FileUtils.mkdir_p("~/.ssh")
+    File.open("~/.ssh/id_rsa.pub", "w") { |f| f << "ssh-key AAbbcc" }
     @client = mock
     Shelly::Client.stub(:new).and_return(@client)
     @user = Shelly::User.new("bob@example.com", "secret")
@@ -25,7 +24,7 @@ describe Shelly::User do
     end
 
     it "should register user at Shelly Cloud" do
-      @client.should_receive(:register_user).with("bob@example.com", "secret")
+      @client.should_receive(:register_user).with("bob@example.com", "secret", "ssh-key AAbbcc")
       @user.register
     end
 
@@ -33,6 +32,21 @@ describe Shelly::User do
       @user.should_receive(:save_credentials)
       @user.register
     end
+
+    context "when ssh key is not available" do
+      it "should register without it" do
+        FileUtils.rm_rf("~/.ssh/id_rsa.pub")
+        @client.should_receive(:register_user).with("bob@example.com", "secret", nil)
+        @user.register
+      end
+    end
+  end
+
+  describe "#token" do
+    it "should return token" do
+      @client.should_receive(:token).and_return({"token" => "abc"})
+      @user.token.should == "abc"
+    end
   end
 
   describe "#save_credentials" do
@@ -42,7 +56,7 @@ describe Shelly::User do
       File.read("~/.shelly/credentials").should == "bob@example.com\nsecret"
     end
 
-    it "should create config_dir if doesn't exist" do
+    it "should create config_dir if it doesn't exist" do
       File.exists?("~/.shelly").should be_false
       @user.save_credentials
       File.exists?("~/.shelly").should be_true
@@ -61,10 +75,34 @@ describe Shelly::User do
       config_dir = File.expand_path("~/.shelly")
       FileUtils.mkdir_p(config_dir)
       File.open(File.join(config_dir, "credentials"), "w") { |f| f << "superman@example.com\nkal-el" }
+
       user = Shelly::User.new
       user.load_credentials
       user.email.should == "superman@example.com"
       user.password.should == "kal-el"
     end
+
+    context "credentials file doesn't exist" do
+      it "should return nil" do
+        user = Shelly::User.new
+        user.load_credentials.should be_nil
+        user.email.should be_nil
+        user.password.should be_nil
+      end
+    end
+  end
+
+  describe "#ssh_key_path" do
+    it "should return path to public ssh key file" do
+      @user.ssh_key_path.should == File.expand_path("~/.ssh/id_rsa.pub")
+    end
+  end
+
+  describe "#ssh_key_exists?" do
+    it "should return true if key exists, false otherwise" do
+      @user.should be_ssh_key_exists
+      FileUtils.rm_rf("~/.ssh/id_rsa.pub")
+      @user.should_not be_ssh_key_exists
+    end
   end
 end

data/spec/spec_helper.rb

@@ -2,9 +2,9 @@ require "rspec"
 require "shelly"
 require "helpers"
 require "input_faker"
-require "fakefs/safe"
 require "fakefs/spec_helpers"
 
 RSpec.configure do |config|
   config.include RSpec::Helpers
+  config.include FakeFS::SpecHelpers
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: shelly
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: false
   segments: 
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Shelly Cloud team
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-15 00:00:00 +02:00
+date: 2011-09-20 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -158,6 +158,20 @@ dependencies:
         version: "0"
   type: :runtime
   version_requirements: *id010
+- !ruby/object:Gem::Dependency 
+  name: launchy
+  prerelease: false
+  requirement: &id011 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id011
 description: Tool for managing applications and clouds at shellycloud.com
 email: 
 - support@shellycloud.com
@@ -177,15 +191,23 @@ files:
 - bin/shelly
 - lib/core_ext/object.rb
 - lib/shelly.rb
-- lib/shelly/cli.rb
+- lib/shelly/app.rb
+- lib/shelly/base.rb
+- lib/shelly/cli/account.rb
+- lib/shelly/cli/apps.rb
+- lib/shelly/cli/main.rb
 - lib/shelly/client.rb
 - lib/shelly/helpers.rb
+- lib/shelly/templates/Cloudfile.erb
 - lib/shelly/user.rb
 - lib/shelly/version.rb
 - shelly.gemspec
 - spec/helpers.rb
 - spec/input_faker.rb
-- spec/shelly/cli_spec.rb
+- spec/shelly/app_spec.rb
+- spec/shelly/cli/account_spec.rb
+- spec/shelly/cli/apps_spec.rb
+- spec/shelly/cli/main_spec.rb
 - spec/shelly/client_spec.rb
 - spec/shelly/user_spec.rb
 - spec/spec_helper.rb
@@ -226,7 +248,10 @@ summary: Shelly Cloud command line tool
 test_files: 
 - spec/helpers.rb
 - spec/input_faker.rb
-- spec/shelly/cli_spec.rb
+- spec/shelly/app_spec.rb
+- spec/shelly/cli/account_spec.rb
+- spec/shelly/cli/apps_spec.rb
+- spec/shelly/cli/main_spec.rb
 - spec/shelly/client_spec.rb
 - spec/shelly/user_spec.rb
 - spec/spec_helper.rb

data/lib/shelly/cli.rb

@@ -1,46 +0,0 @@
-require "shelly"
-require "shelly/user"
-
-module Shelly
-  class CLI < Thor
-    include Helpers
-    include Thor::Actions
-
-    map %w(-v --version) => :version
-    desc "version", "Displays shelly version"
-    def version
-      say "shelly version #{Shelly::VERSION}"
-    end
-
-    desc "register", "Registers new user at Shelly Cloud"
-    def register
-      email_question = User.guess_email.blank? ? "Email:" : "Email (default #{User.guess_email}):"
-      email = ask(email_question)
-      email = User.guess_email if email.blank?
-      password = ask_for_password
-
-      if email.blank? or password.blank?
-        say "Email and password can't be blank" and exit 1
-      end
-
-      user = User.new(email, password)
-      if user.register
-        say "Successfully registered!\nCheck you mailbox for email confirmation"
-      end
-    rescue Client::APIError => e
-      if e.message == "Validation Failed"
-        e.errors.each { |error| say "#{error.first} #{error.last}" }
-      end
-    end
-
-    no_tasks do
-      def ask_for_password
-        say "Password: "
-        echo_off
-        password = $stdin.gets.strip
-        echo_on
-        password
-      end
-    end
-  end
-end